//------------------------------------------------------------------------------
// The contents of this file are subject to the nopCommerce Public License Version 1.0 ("License"); you may not use this file except in compliance with the License.
// You may obtain a copy of the License at  http://www.nopCommerce.com/License.aspx. 
// 
// Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. 
// See the License for the specific language governing rights and limitations under the License.
// 
// The Original Code is nopCommerce.
// The Initial Developer of the Original Code is NopSolutions.
// All Rights Reserved.
// 
// Contributor(s): _______. 
//------------------------------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Threading;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using NopSolutions.NopCommerce.Common.Categories;
using NopSolutions.NopCommerce.Common.Media;
using NopSolutions.NopCommerce.Common.Products;
using NopSolutions.NopCommerce.Common.Promo.Discounts;
using NopSolutions.NopCommerce.Common.Templates;
using NopSolutions.NopCommerce.Common.Utils;
using NopSolutions.NopCommerce.Web.Administration.Modules;
 

namespace NopSolutions.NopCommerce.Web.Administration.Modules
{
    public partial class CategoryProductControl : BaseNopAdministrationUserControl
    {
        private void BindData()
        {
            Category category = CategoryManager.GetCategoryByID(this.CategoryID);

            if (category != null)
            {
                ProductCategoryCollection existingProductCategoryCollection = category.ProductCategories;
                List<ProductCategoryMappingHelperClass> productCategoryMappings = GetProductCategoryMappings(existingProductCategoryCollection);
                gvProductCategoryMappings.DataSource = productCategoryMappings;
                gvProductCategoryMappings.DataBind();
            }
        }


        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                this.BindData();
            }
            else
            {
                UpdateState();
            }
        }

        public void SaveInfo()
        {
            Category category = CategoryManager.GetCategoryByID(this.CategoryID);

            if (category != null)
            {
                foreach (ProductCategoryMappingHelperClass item in GridState.Values)
                {
                    if (item.IsMapped && (item.ProductCategoryID > 0))
                        CategoryManager.UpdateProductCategory(item.ProductCategoryID, item.ProductID, category.CategoryID, item.IsFeatured, item.DisplayOrder);
                    else if (item.IsMapped && (item.ProductCategoryID == 0))
                        CategoryManager.InsertProductCategory(item.ProductID, category.CategoryID, item.IsFeatured, item.DisplayOrder);
                    else if (!item.IsMapped && (item.ProductCategoryID > 0))
                        CategoryManager.DeleteProductCategory(item.ProductCategoryID);
                }

            }
        }

        protected void gvProductCategoryMappings_PageIndexChanging(object sender, GridViewPageEventArgs e)
        {
            gvProductCategoryMappings.PageIndex = e.NewPageIndex;
            BindData();
        }

        private List<ProductCategoryMappingHelperClass> GetProductCategoryMappings(ProductCategoryCollection ExistingProductCategoryCollection)
        {
            ProductCollection productCollection = ProductManager.GetAllProducts();
            List<ProductCategoryMappingHelperClass> result = new List<ProductCategoryMappingHelperClass>();
            for (int i = 0; i < productCollection.Count; i++)
            {
                Product product = productCollection[i];
                ProductCategory existingProductCategory = ExistingProductCategoryCollection.FindProductCategory(product.ProductID, this.CategoryID);
                ProductCategoryMappingHelperClass pcm = new ProductCategoryMappingHelperClass();
                if (existingProductCategory != null)
                {
                    pcm.ProductCategoryID = existingProductCategory.ProductCategoryID;
                    pcm.IsMapped = true;
                    pcm.IsFeatured = existingProductCategory.IsFeaturedProduct;
                    pcm.DisplayOrder = existingProductCategory.DisplayOrder;
                }
                else
                {
                    pcm.DisplayOrder = 1;
                }
                pcm.ProductID = product.ProductID;
                pcm.ProductInfo = product.Name;

                MapState(product.ProductID, pcm);

                result.Add(pcm);
            }

            return result;
        }

        [Serializable]
        private class ProductCategoryMappingHelperClass
        {
            public int ProductCategoryID { get; set; }
            public int ProductID { get; set; }
            public string ProductInfo { get; set; }
            public bool IsMapped { get; set; }
            public bool IsFeatured { get; set; }
            public int DisplayOrder { get; set; }
        }

        public int CategoryID
        {
            get
            {
                return CommonHelper.QueryStringInt("CategoryID");
            }
        }

        private Dictionary<int, ProductCategoryMappingHelperClass> _gridState;
        private Dictionary<int, ProductCategoryMappingHelperClass> GridState
        {
            get
            {
                if (_gridState == null)
                {
                    _gridState = ViewState["ProductCategoryState"] as Dictionary<int, ProductCategoryMappingHelperClass>;
                    if (_gridState == null)
                    {
                        _gridState = new Dictionary<int, ProductCategoryMappingHelperClass>();
                        ViewState["ProductCategoryState"] = _gridState;
                    }
                }
                return _gridState;
            }

            set
            {
                _gridState = value;
                ViewState["ProductCategoryState"] = value;
            }
        }

        private void UpdateState()
        {
            Dictionary<int, ProductCategoryMappingHelperClass> state = GridState;
            foreach (GridViewRow row in gvProductCategoryMappings.Rows)
            {
                CheckBox cbProductInfo = row.FindControl("cbProductInfo") as CheckBox;
                HiddenField hfProductID = row.FindControl("hfProductID") as HiddenField;
                HiddenField hfProductCategoryID = row.FindControl("hfProductCategoryID") as HiddenField;
                CheckBox cbFeatured = row.FindControl("cbFeatured") as CheckBox;
                NumericTextBox txtRowDisplayOrder = row.FindControl("txtDisplayOrder") as NumericTextBox;
                int productCategoryID = int.Parse(hfProductCategoryID.Value);
                int productID = int.Parse(hfProductID.Value);
                int displayOrder = txtRowDisplayOrder.Value;

                if (cbProductInfo.Checked || (productCategoryID > 0))
                {
                    state[productID] = new ProductCategoryMappingHelperClass()
                    {
                        ProductID = productID,
                        ProductCategoryID = productCategoryID,
                        IsMapped = cbProductInfo.Checked,
                        DisplayOrder = displayOrder,
                        IsFeatured = cbFeatured.Checked
                    };
                }
                else if (state.ContainsKey(productID))
                {
                    state.Remove(productID);
                }
            }
            GridState = state;
        }

        private void MapState(int Id, ProductCategoryMappingHelperClass rp)
        {
            if (GridState.ContainsKey(Id))
            {
                ProductCategoryMappingHelperClass srp = GridState[Id];
                rp.IsMapped = srp.IsMapped;
                rp.DisplayOrder = srp.DisplayOrder;
                rp.IsFeatured = srp.IsFeatured;
            }
        }
    }
}